package com.niit.scala

import scala.collection.immutable.Map

/**
 * Date:2025/3/25
 * Author：Ys
 * Description:
 */
object Base08 {

  def main(args: Array[String]): Unit = {
    /*
      集： set
       1.不可变集
       2.可变集
       3.集的操作
     */
    //不可变集： 唯一 无序(添加的顺序和取出的顺序是不一致)
    var set1 = Set[Int]()  //不可变的空集
    var set2 = Set(2,1,4,1,2,4,9,8)
    println(set2)

    //可变集 要想使用可变集 需要引入包
     import scala.collection.mutable.Set
    var set3 = Set(1,2,3,4,1,2,3,5,1,6)
    //可变集的操作 += ++= -= --=
    set3 += 10
    set3 --= Set(1,2,3)
    println(set3)


    /*
     映射  --> 字典 --> Map --= 键值对
     1.不可变映射
     2.可变映射
     3.映射的操作
     */
    //1.不可变映射
    var map1 = Map("张三"->23,"李四"->24,"王五"->25) //方式一 不常用
    var map2 = Map( ("张三",23) ,  ("李四",24), ("王五",25)  ) //方式二 常用
    println(map1,map2)

    //2.可变映射  需要手动引入包
    import scala.collection.mutable.Map
    var map3 = Map( ("张三",23) ,  ("李四",24), ("王五",25)  )


    //Map的修改
    //根据键修改值
    map3("张三") = 40
    println(map3)
    //根据键获得值
    //println(map3("李三")) 方式一
    println( map3.get("李三") ) //方式二，如果该键不存在，也不会报错，返回None

    //获得所有键 和 所有值
    println(map3.keys)
    println(map3.values)

    //遍历映射
    for( (k,v) <- map3 ){
      println(k,v)
    }


    /*
      迭代器：Scala针对每一类集合都提供一个迭代器，用来左集合遍历访问
      迭代器通常会和while配合使用
      hasNext:查询迭代器中是否有下一个元素
      next:取出迭代器中的下一个元素
     */

    var list1 = List(1,2,3,4,5,6,7,8,9)
    var iterator1 = list1.iterator //列表创建迭代器
    while (iterator1.hasNext){
      println(iterator1.next())
    }

    /*
     函数式编程：方法的参数列表可以接收函数对象
     */
    //foreach  循环
    var list2 = List(1,2,3,4,5,6,7)
    // 用foreach对list2进行遍历
    //初级版  i:Int  表示列表中的每一个元素
    list2.foreach( (i:Int) =>  println(i)      )
    //升级版
    list2.foreach( i =>  println( i ))  //利用Scala的类型推断的特性
    //究极版 _:  表示列表中的每一个元素
    list2.foreach(println(_))

    //map: 集合的映射操作 将一种数据类型转换为另一种数据类型   对每一个元素进行操作，并将结果返回给新的列表
    //需求：某电影网站，需要观众对电影进行打分，等级：1，2，3，4 。但是观众只能通过 * 来表示等级，需要将1，2，3，4 转换为 *****
    var list3 = List(1,2,3,4)
   //初级版
    val ll1: List[String] = list3.map((i: Int) => "*" * i)
    println(ll1)
    //升级版
    val ll2: List[String] = list3.map(i => "*" * i)
    //究极版
    val ll3: List[String] = list3.map("*" * _)
    /*
     map 和 foreach 最大区别： map会将函数的返回值，作为新的列表的元素。foreach没有返回值
     */

    //flatMap  :  map + flatten[扁平化]
    // 1. map :将列表中每一个元素进行操作，并将结果返回给新的列表
    //2.flatten: 将嵌套列表中的所有元素，单独提取出来，组成一个新的列表
    var list4 = List(  "hadoop hive spark flume", "hbase java python java"  )
    //==> List(haddop,hive,spark,flume,hbase,java,python,java)
    // 传统方式
    val ll4: List[Array[String]] = list4.map(_.split(" "))
    println(ll4) //List(Array(hadoop, hive, spark, flume), Array(hbase, java, python, java))
    val ll5: List[String] = ll4.flatten
    println(ll5)

    //flatMap 方式
    val ll6: List[String] = list4.flatMap(_.split(" "))
    println(ll6)
  }

}
